home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Freeware / Adobe Air 1.5 / AdobeAIRInstaller.exe / setup.swf / scripts / mx / controls / List.as < prev    next >
Encoding:
Text File  |  2008-10-29  |  63.6 KB  |  1,847 lines
  1. package mx.controls
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.Graphics;
  5.    import flash.display.Shape;
  6.    import flash.display.Sprite;
  7.    import flash.events.Event;
  8.    import flash.events.FocusEvent;
  9.    import flash.events.KeyboardEvent;
  10.    import flash.events.MouseEvent;
  11.    import flash.geom.Point;
  12.    import flash.ui.Keyboard;
  13.    import flash.utils.Dictionary;
  14.    import mx.collections.CursorBookmark;
  15.    import mx.collections.IList;
  16.    import mx.collections.ItemResponder;
  17.    import mx.collections.ItemWrapper;
  18.    import mx.collections.ModifiedCollectionView;
  19.    import mx.collections.errors.ItemPendingError;
  20.    import mx.controls.listClasses.BaseListData;
  21.    import mx.controls.listClasses.IDropInListItemRenderer;
  22.    import mx.controls.listClasses.IListItemRenderer;
  23.    import mx.controls.listClasses.ListBase;
  24.    import mx.controls.listClasses.ListBaseSeekPending;
  25.    import mx.controls.listClasses.ListData;
  26.    import mx.controls.listClasses.ListItemRenderer;
  27.    import mx.controls.listClasses.ListRowInfo;
  28.    import mx.controls.scrollClasses.ScrollBar;
  29.    import mx.core.ClassFactory;
  30.    import mx.core.EdgeMetrics;
  31.    import mx.core.EventPriority;
  32.    import mx.core.FlexShape;
  33.    import mx.core.FlexSprite;
  34.    import mx.core.FlexVersion;
  35.    import mx.core.IFactory;
  36.    import mx.core.IIMESupport;
  37.    import mx.core.IInvalidating;
  38.    import mx.core.IPropertyChangeNotifier;
  39.    import mx.core.ScrollPolicy;
  40.    import mx.core.UIComponent;
  41.    import mx.core.UIComponentGlobals;
  42.    import mx.core.mx_internal;
  43.    import mx.events.CollectionEvent;
  44.    import mx.events.CollectionEventKind;
  45.    import mx.events.ListEvent;
  46.    import mx.events.ListEventReason;
  47.    import mx.events.ScrollEvent;
  48.    import mx.events.ScrollEventDetail;
  49.    import mx.managers.IFocusManager;
  50.    import mx.managers.IFocusManagerComponent;
  51.    import mx.styles.StyleManager;
  52.    
  53.    use namespace mx_internal;
  54.    
  55.    public class List extends ListBase implements IIMESupport
  56.    {
  57.       mx_internal static var createAccessibilityImplementation:Function;
  58.       
  59.       mx_internal static const VERSION:String = "3.0.0.0";
  60.       
  61.       public var editorXOffset:Number = 0;
  62.       
  63.       public var itemEditorInstance:IListItemRenderer;
  64.       
  65.       public var rendererIsEditor:Boolean = false;
  66.       
  67.       private var dontEdit:Boolean = false;
  68.       
  69.       public var editorYOffset:Number = 0;
  70.       
  71.       public var editorWidthOffset:Number = 0;
  72.       
  73.       private var lastEditedItemPosition:*;
  74.       
  75.       public var itemEditor:IFactory;
  76.       
  77.       public var editable:Boolean = false;
  78.       
  79.       private var losingFocus:Boolean = false;
  80.       
  81.       public var editorUsesEnterKey:Boolean = false;
  82.       
  83.       public var editorDataField:String = "text";
  84.       
  85.       private var bEditedItemPositionChanged:Boolean = false;
  86.       
  87.       mx_internal var _lockedRowCount:int = 0;
  88.       
  89.       private var inEndEdit:Boolean = false;
  90.       
  91.       public var editorHeightOffset:Number = 0;
  92.       
  93.       private var _editedItemPosition:Object;
  94.       
  95.       private var _imeMode:String;
  96.       
  97.       private var actualRowIndex:int;
  98.       
  99.       private var _proposedEditedItemPosition:*;
  100.       
  101.       private var actualColIndex:int = 0;
  102.       
  103.       protected var measuringObjects:Dictionary;
  104.       
  105.       public function List()
  106.       {
  107.          itemEditor = new ClassFactory(TextInput);
  108.          super();
  109.          mx_internal::listType = "vertical";
  110.          mx_internal::bColumnScrolling = false;
  111.          itemRenderer = new ClassFactory(ListItemRenderer);
  112.          mx_internal::_horizontalScrollPolicy = ScrollPolicy.OFF;
  113.          mx_internal::_verticalScrollPolicy = ScrollPolicy.AUTO;
  114.          defaultColumnCount = 1;
  115.          defaultRowCount = 7;
  116.          addEventListener(ListEvent.ITEM_EDIT_BEGINNING,itemEditorItemEditBeginningHandler,false,EventPriority.DEFAULT_HANDLER);
  117.          addEventListener(ListEvent.ITEM_EDIT_BEGIN,itemEditorItemEditBeginHandler,false,EventPriority.DEFAULT_HANDLER);
  118.          addEventListener(ListEvent.ITEM_EDIT_END,itemEditorItemEditEndHandler,false,EventPriority.DEFAULT_HANDLER);
  119.       }
  120.       
  121.       override public function measureWidthOfItems(param1:int = -1, param2:int = 0) : Number
  122.       {
  123.          var i:int;
  124.          var paddingRight:Number;
  125.          var more:Boolean;
  126.          var bookmark:CursorBookmark;
  127.          var w:Number;
  128.          var paddingLeft:Number;
  129.          var item:IListItemRenderer = null;
  130.          var rw:Number = NaN;
  131.          var data:Object = null;
  132.          var factory:IFactory = null;
  133.          var index:int = param1;
  134.          var count:int = param2;
  135.          if(count == 0)
  136.          {
  137.             count = !!collection ? collection.length : 0;
  138.          }
  139.          if(Boolean(collection) && collection.length == 0)
  140.          {
  141.             count = 0;
  142.          }
  143.          w = 0;
  144.          bookmark = !!iterator ? iterator.bookmark : null;
  145.          if(index != -1 && Boolean(iterator))
  146.          {
  147.             try
  148.             {
  149.                iterator.seek(CursorBookmark.FIRST,index);
  150.             }
  151.             catch(e:ItemPendingError)
  152.             {
  153.                return 0;
  154.             }
  155.          }
  156.          more = iterator != null;
  157.          i = 0;
  158.          while(i < count)
  159.          {
  160.             if(more)
  161.             {
  162.                data = iterator.current;
  163.                factory = getItemRendererFactory(data);
  164.                item = measuringObjects[factory];
  165.                if(!item)
  166.                {
  167.                   item = mx_internal::getMeasuringRenderer(data);
  168.                }
  169.                item.explicitWidth = NaN;
  170.                mx_internal::setupRendererFromData(item,data);
  171.                rw = Number(item.measuredWidth);
  172.                w = Math.max(w,rw);
  173.             }
  174.             if(more)
  175.             {
  176.                try
  177.                {
  178.                   more = iterator.moveNext();
  179.                }
  180.                catch(e:ItemPendingError)
  181.                {
  182.                   more = false;
  183.                }
  184.             }
  185.             i++;
  186.          }
  187.          if(iterator)
  188.          {
  189.             iterator.seek(bookmark,0);
  190.          }
  191.          if(w == 0)
  192.          {
  193.             if(explicitWidth)
  194.             {
  195.                return explicitWidth;
  196.             }
  197.             return DEFAULT_MEASURED_WIDTH;
  198.          }
  199.          paddingLeft = getStyle("paddingLeft");
  200.          paddingRight = getStyle("paddingRight");
  201.          w += paddingLeft + paddingRight;
  202.          return w;
  203.       }
  204.       
  205.       private function findNextEnterItemRenderer(param1:KeyboardEvent) : void
  206.       {
  207.          if(_proposedEditedItemPosition !== undefined)
  208.          {
  209.             return;
  210.          }
  211.          _editedItemPosition = lastEditedItemPosition;
  212.          var _loc2_:int = int(_editedItemPosition.rowIndex);
  213.          var _loc3_:int = int(_editedItemPosition.columnIndex);
  214.          var _loc4_:int = _editedItemPosition.rowIndex + (param1.shiftKey ? -1 : 1);
  215.          if(_loc4_ < collection.length && _loc4_ >= 0)
  216.          {
  217.             _loc2_ = _loc4_;
  218.          }
  219.          var _loc5_:ListEvent = new ListEvent(ListEvent.ITEM_EDIT_BEGINNING,false,true);
  220.          _loc5_.rowIndex = _loc2_;
  221.          _loc5_.columnIndex = 0;
  222.          dispatchEvent(_loc5_);
  223.       }
  224.       
  225.       public function get imeMode() : String
  226.       {
  227.          return _imeMode;
  228.       }
  229.       
  230.       private function mouseFocusChangeHandler(param1:MouseEvent) : void
  231.       {
  232.          if(itemEditorInstance && !param1.isDefaultPrevented() && itemRendererContains(itemEditorInstance,DisplayObject(param1.target)))
  233.          {
  234.             param1.preventDefault();
  235.          }
  236.       }
  237.       
  238.       public function set imeMode(param1:String) : void
  239.       {
  240.          _imeMode = param1;
  241.       }
  242.       
  243.       override protected function mouseUpHandler(param1:MouseEvent) : void
  244.       {
  245.          var _loc2_:ListEvent = null;
  246.          var _loc3_:IListItemRenderer = null;
  247.          var _loc4_:Sprite = null;
  248.          var _loc5_:int = 0;
  249.          var _loc6_:int = 0;
  250.          var _loc7_:Point = null;
  251.          _loc3_ = mouseEventToItemRenderer(param1);
  252.          super.mouseUpHandler(param1);
  253.          if(_loc3_ && _loc3_.data && _loc3_ != itemEditorInstance)
  254.          {
  255.             _loc7_ = itemRendererToIndices(_loc3_);
  256.             if(editable && !dontEdit)
  257.             {
  258.                _loc2_ = new ListEvent(ListEvent.ITEM_EDIT_BEGINNING,false,true);
  259.                _loc2_.rowIndex = _loc7_.y;
  260.                _loc2_.columnIndex = 0;
  261.                _loc2_.itemRenderer = _loc3_;
  262.                dispatchEvent(_loc2_);
  263.             }
  264.          }
  265.       }
  266.       
  267.       private function itemEditorItemEditEndHandler(param1:ListEvent) : void
  268.       {
  269.          var bChanged:Boolean = false;
  270.          var bFieldChanged:Boolean = false;
  271.          var newData:Object = null;
  272.          var data:Object = null;
  273.          var editCollection:IList = null;
  274.          var listData:BaseListData = null;
  275.          var fm:IFocusManager = null;
  276.          var event:ListEvent = param1;
  277.          if(!event.isDefaultPrevented())
  278.          {
  279.             bChanged = false;
  280.             bFieldChanged = false;
  281.             newData = itemEditorInstance[editorDataField];
  282.             data = event.itemRenderer.data;
  283.             if(data is String)
  284.             {
  285.                if(!(newData is String))
  286.                {
  287.                   newData = newData.toString();
  288.                }
  289.             }
  290.             else if(data is uint)
  291.             {
  292.                if(!(newData is uint))
  293.                {
  294.                   newData = uint(newData);
  295.                }
  296.             }
  297.             else if(data is int)
  298.             {
  299.                if(!(newData is int))
  300.                {
  301.                   newData = int(newData);
  302.                }
  303.             }
  304.             else if(data is Number)
  305.             {
  306.                if(!(newData is int))
  307.                {
  308.                   newData = Number(newData);
  309.                }
  310.             }
  311.             else
  312.             {
  313.                bFieldChanged = true;
  314.                try
  315.                {
  316.                   data[labelField] = newData;
  317.                   if(!(data is IPropertyChangeNotifier))
  318.                   {
  319.                      if(actualCollection)
  320.                      {
  321.                         actualCollection.itemUpdated(data,labelField);
  322.                      }
  323.                      else
  324.                      {
  325.                         collection.itemUpdated(data,labelField);
  326.                      }
  327.                   }
  328.                }
  329.                catch(e:Error)
  330.                {
  331.                   trace("attempt to write to",labelField,"failed.  You may need a custom ITEM_EDIT_END handler");
  332.                }
  333.             }
  334.             if(!bFieldChanged)
  335.             {
  336.                if(data !== newData)
  337.                {
  338.                   bChanged = true;
  339.                   data = newData;
  340.                }
  341.                if(bChanged)
  342.                {
  343.                   editCollection = !!actualCollection ? actualCollection as IList : collection as IList;
  344.                   if(editCollection)
  345.                   {
  346.                      IList(editCollection).setItemAt(data,event.rowIndex);
  347.                   }
  348.                   else
  349.                   {
  350.                      trace("attempt to update collection failed.  You may need a custom ITEM_EDIT_END handler");
  351.                   }
  352.                }
  353.             }
  354.             if(event.itemRenderer is IDropInListItemRenderer)
  355.             {
  356.                listData = BaseListData(IDropInListItemRenderer(event.itemRenderer).listData);
  357.                listData.label = itemToLabel(data);
  358.                IDropInListItemRenderer(event.itemRenderer).listData = listData;
  359.             }
  360.             delete visibleData[itemToUID(event.itemRenderer.data)];
  361.             event.itemRenderer.data = data;
  362.             visibleData[itemToUID(data)] = event.itemRenderer;
  363.          }
  364.          else if(event.reason != ListEventReason.OTHER)
  365.          {
  366.             if(Boolean(itemEditorInstance) && Boolean(_editedItemPosition))
  367.             {
  368.                if(selectedIndex != _editedItemPosition.rowIndex)
  369.                {
  370.                   selectedIndex = _editedItemPosition.rowIndex;
  371.                }
  372.                fm = focusManager;
  373.                if(itemEditorInstance is IFocusManagerComponent)
  374.                {
  375.                   fm.setFocus(IFocusManagerComponent(itemEditorInstance));
  376.                }
  377.             }
  378.          }
  379.          if(event.reason == ListEventReason.OTHER || !event.isDefaultPrevented())
  380.          {
  381.             destroyItemEditor();
  382.          }
  383.       }
  384.       
  385.       private function itemEditorItemEditBeginningHandler(param1:ListEvent) : void
  386.       {
  387.          if(!param1.isDefaultPrevented())
  388.          {
  389.             setEditedItemPosition({
  390.                "columnIndex":param1.columnIndex,
  391.                "rowIndex":param1.rowIndex
  392.             });
  393.          }
  394.          else if(!itemEditorInstance)
  395.          {
  396.             _editedItemPosition = null;
  397.             editable = false;
  398.             setFocus();
  399.             editable = true;
  400.          }
  401.       }
  402.       
  403.       override public function createItemRenderer(param1:Object) : IListItemRenderer
  404.       {
  405.          var _loc2_:IFactory = null;
  406.          var _loc3_:IListItemRenderer = null;
  407.          var _loc4_:Dictionary = null;
  408.          var _loc5_:* = undefined;
  409.          _loc2_ = getItemRendererFactory(param1);
  410.          if(!_loc2_)
  411.          {
  412.             if(param1 == null)
  413.             {
  414.                _loc2_ = nullItemRenderer;
  415.             }
  416.             if(!_loc2_)
  417.             {
  418.                _loc2_ = itemRenderer;
  419.             }
  420.          }
  421.          if(_loc2_ == itemRenderer)
  422.          {
  423.             if(Boolean(freeItemRenderers) && Boolean(freeItemRenderers.length))
  424.             {
  425.                _loc3_ = freeItemRenderers.pop();
  426.                delete freeItemRenderersByFactory[_loc2_][_loc3_];
  427.             }
  428.          }
  429.          else if(freeItemRenderersByFactory)
  430.          {
  431.             _loc4_ = freeItemRenderersByFactory[_loc2_];
  432.             if(_loc4_)
  433.             {
  434.                var _loc6_:int = 0;
  435.                var _loc7_:* = _loc4_;
  436.                for(_loc5_ in _loc7_)
  437.                {
  438.                   _loc3_ = IListItemRenderer(_loc5_);
  439.                   delete _loc4_[_loc5_];
  440.                }
  441.             }
  442.          }
  443.          if(!_loc3_)
  444.          {
  445.             _loc3_ = _loc2_.newInstance();
  446.             _loc3_.styleName = this;
  447.             factoryMap[_loc3_] = _loc2_;
  448.          }
  449.          _loc3_.owner = this;
  450.          return _loc3_;
  451.       }
  452.       
  453.       override protected function focusOutHandler(param1:FocusEvent) : void
  454.       {
  455.          if(param1.target == this)
  456.          {
  457.             super.focusOutHandler(param1);
  458.          }
  459.          if(param1.relatedObject == this && itemRendererContains(itemEditorInstance,DisplayObject(param1.target)))
  460.          {
  461.             return;
  462.          }
  463.          if(param1.relatedObject == null && itemRendererContains(editedItemRenderer,DisplayObject(param1.target)))
  464.          {
  465.             return;
  466.          }
  467.          if(param1.relatedObject == null && itemRendererContains(itemEditorInstance,DisplayObject(param1.target)))
  468.          {
  469.             return;
  470.          }
  471.          if(Boolean(itemEditorInstance) && (!param1.relatedObject || !itemRendererContains(itemEditorInstance,param1.relatedObject)))
  472.          {
  473.             endEdit(ListEventReason.OTHER);
  474.             removeEventListener(FocusEvent.KEY_FOCUS_CHANGE,keyFocusChangeHandler);
  475.             removeEventListener(MouseEvent.MOUSE_DOWN,mouseFocusChangeHandler);
  476.          }
  477.       }
  478.       
  479.       override protected function scrollHorizontally(param1:int, param2:int, param3:Boolean) : void
  480.       {
  481.          var _loc4_:int = int(listItems.length);
  482.          var _loc5_:Number = getStyle("paddingLeft");
  483.          var _loc6_:int = 0;
  484.          while(_loc6_ < _loc4_)
  485.          {
  486.             if(listItems[_loc6_].length)
  487.             {
  488.                listItems[_loc6_][0].x = -param1 + _loc5_;
  489.             }
  490.             _loc6_++;
  491.          }
  492.       }
  493.       
  494.       override protected function drawHighlightIndicator(param1:Sprite, param2:Number, param3:Number, param4:Number, param5:Number, param6:uint, param7:IListItemRenderer) : void
  495.       {
  496.          super.drawHighlightIndicator(param1,0,param3,unscaledWidth - viewMetrics.left - viewMetrics.right,param5,param6,param7);
  497.       }
  498.       
  499.       [Bindable("itemFocusIn")]
  500.       public function get editedItemPosition() : Object
  501.       {
  502.          if(_editedItemPosition)
  503.          {
  504.             return {
  505.                "rowIndex":_editedItemPosition.rowIndex,
  506.                "columnIndex":0
  507.             };
  508.          }
  509.          return _editedItemPosition;
  510.       }
  511.       
  512.       private function setEditedItemPosition(param1:Object) : void
  513.       {
  514.          bEditedItemPositionChanged = true;
  515.          _proposedEditedItemPosition = param1;
  516.          invalidateDisplayList();
  517.       }
  518.       
  519.       override protected function drawRowBackgrounds() : void
  520.       {
  521.          var _loc2_:Array = null;
  522.          var _loc6_:int = 0;
  523.          var _loc1_:Sprite = Sprite(listContent.getChildByName("rowBGs"));
  524.          if(!_loc1_)
  525.          {
  526.             _loc1_ = new FlexSprite();
  527.             _loc1_.mouseEnabled = false;
  528.             _loc1_.name = "rowBGs";
  529.             listContent.addChildAt(_loc1_,0);
  530.          }
  531.          _loc2_ = getStyle("alternatingItemColors");
  532.          if(!_loc2_ || _loc2_.length == 0)
  533.          {
  534.             while(_loc1_.numChildren > _loc6_)
  535.             {
  536.                _loc1_.removeChildAt(_loc1_.numChildren - 1);
  537.             }
  538.             return;
  539.          }
  540.          StyleManager.getColorNames(_loc2_);
  541.          var _loc3_:int = 0;
  542.          var _loc4_:int = verticalScrollPosition;
  543.          var _loc5_:int = 0;
  544.          _loc6_ = int(listItems.length);
  545.          while(_loc3_ < _loc6_)
  546.          {
  547.             drawRowBackground(_loc1_,_loc5_++,rowInfo[_loc3_].y,rowInfo[_loc3_].height,_loc2_[_loc4_ % _loc2_.length],_loc4_);
  548.             _loc3_++;
  549.             _loc4_++;
  550.          }
  551.          while(_loc1_.numChildren > _loc6_)
  552.          {
  553.             _loc1_.removeChildAt(_loc1_.numChildren - 1);
  554.          }
  555.       }
  556.       
  557.       override protected function drawCaretIndicator(param1:Sprite, param2:Number, param3:Number, param4:Number, param5:Number, param6:uint, param7:IListItemRenderer) : void
  558.       {
  559.          super.drawCaretIndicator(param1,0,param3,unscaledWidth - viewMetrics.left - viewMetrics.right,param5,param6,param7);
  560.       }
  561.       
  562.       private function deactivateHandler(param1:Event) : void
  563.       {
  564.          if(itemEditorInstance)
  565.          {
  566.             endEdit(ListEventReason.OTHER);
  567.             losingFocus = true;
  568.             setFocus();
  569.          }
  570.       }
  571.       
  572.       protected function layoutEditor(param1:int, param2:int, param3:int, param4:int) : void
  573.       {
  574.          itemEditorInstance.move(param1,param2);
  575.          itemEditorInstance.setActualSize(param3,param4);
  576.       }
  577.       
  578.       private function editorKeyDownHandler(param1:KeyboardEvent) : void
  579.       {
  580.          if(param1.keyCode == Keyboard.ESCAPE)
  581.          {
  582.             endEdit(ListEventReason.CANCELLED);
  583.          }
  584.          else if(param1.ctrlKey && param1.charCode == 46)
  585.          {
  586.             endEdit(ListEventReason.CANCELLED);
  587.          }
  588.          else if(param1.charCode == Keyboard.ENTER && param1.keyCode != 229)
  589.          {
  590.             if(editorUsesEnterKey)
  591.             {
  592.                return;
  593.             }
  594.             if(endEdit(ListEventReason.NEW_ROW))
  595.             {
  596.                if(!dontEdit)
  597.                {
  598.                   findNextEnterItemRenderer(param1);
  599.                }
  600.             }
  601.          }
  602.       }
  603.       
  604.       private function itemEditorItemEditBeginHandler(param1:ListEvent) : void
  605.       {
  606.          var _loc2_:IFocusManager = null;
  607.          stage.addEventListener(Event.DEACTIVATE,deactivateHandler,false,0,true);
  608.          if(!param1.isDefaultPrevented() && listItems[actualRowIndex][actualColIndex].data != null)
  609.          {
  610.             createItemEditor(param1.columnIndex,param1.rowIndex);
  611.             if(editedItemRenderer is IDropInListItemRenderer && itemEditorInstance is IDropInListItemRenderer)
  612.             {
  613.                IDropInListItemRenderer(itemEditorInstance).listData = IDropInListItemRenderer(editedItemRenderer).listData;
  614.             }
  615.             if(!rendererIsEditor)
  616.             {
  617.                itemEditorInstance.data = editedItemRenderer.data;
  618.             }
  619.             if(itemEditorInstance is IInvalidating)
  620.             {
  621.                IInvalidating(itemEditorInstance).validateNow();
  622.             }
  623.             if(itemEditorInstance is IIMESupport)
  624.             {
  625.                IIMESupport(itemEditorInstance).imeMode = imeMode;
  626.             }
  627.             _loc2_ = focusManager;
  628.             if(itemEditorInstance is IFocusManagerComponent)
  629.             {
  630.                _loc2_.setFocus(IFocusManagerComponent(itemEditorInstance));
  631.             }
  632.             _loc2_.defaultButtonEnabled = false;
  633.             param1 = new ListEvent(ListEvent.ITEM_FOCUS_IN);
  634.             param1.rowIndex = _editedItemPosition.rowIndex;
  635.             param1.itemRenderer = itemEditorInstance;
  636.             dispatchEvent(param1);
  637.          }
  638.       }
  639.       
  640.       private function editingTemporarilyPrevented(param1:Object) : Boolean
  641.       {
  642.          var _loc2_:int = 0;
  643.          var _loc3_:IListItemRenderer = null;
  644.          if(runningDataEffect && Boolean(param1))
  645.          {
  646.             _loc2_ = param1.rowIndex - verticalScrollPosition + offscreenExtraRowsTop;
  647.             if(_loc2_ < 0 || _loc2_ >= listItems.length)
  648.             {
  649.                return false;
  650.             }
  651.             _loc3_ = listItems[_loc2_][0];
  652.             if(Boolean(_loc3_) && (Boolean(getRendererSemanticValue(_loc3_,"replaced")) || Boolean(getRendererSemanticValue(_loc3_,"removed"))))
  653.             {
  654.                return true;
  655.             }
  656.          }
  657.          return false;
  658.       }
  659.       
  660.       override public function measureHeightOfItems(param1:int = -1, param2:int = 0) : Number
  661.       {
  662.          var ww:Number;
  663.          var paddingTop:Number;
  664.          var rh:Number;
  665.          var i:int;
  666.          var h:Number;
  667.          var more:Boolean;
  668.          var paddingBottom:Number;
  669.          var bookmark:CursorBookmark;
  670.          var data:Object = null;
  671.          var item:IListItemRenderer = null;
  672.          var index:int = param1;
  673.          var count:int = param2;
  674.          if(count == 0)
  675.          {
  676.             count = !!collection ? collection.length : 0;
  677.          }
  678.          paddingTop = getStyle("paddingTop");
  679.          paddingBottom = getStyle("paddingBottom");
  680.          ww = 200;
  681.          if(listContent.width)
  682.          {
  683.             ww = listContent.width;
  684.          }
  685.          h = 0;
  686.          bookmark = !!iterator ? iterator.bookmark : null;
  687.          if(index != -1 && Boolean(iterator))
  688.          {
  689.             iterator.seek(CursorBookmark.FIRST,index);
  690.          }
  691.          rh = rowHeight;
  692.          more = iterator != null;
  693.          i = 0;
  694.          while(i < count)
  695.          {
  696.             if(more)
  697.             {
  698.                rh = rowHeight;
  699.                data = iterator.current;
  700.                item = mx_internal::getMeasuringRenderer(data);
  701.                item.explicitWidth = ww;
  702.                mx_internal::setupRendererFromData(item,data);
  703.                if(variableRowHeight)
  704.                {
  705.                   rh = item.getExplicitOrMeasuredHeight() + paddingTop + paddingBottom;
  706.                }
  707.             }
  708.             h += rh;
  709.             if(more)
  710.             {
  711.                try
  712.                {
  713.                   more = iterator.moveNext();
  714.                }
  715.                catch(e:ItemPendingError)
  716.                {
  717.                   more = false;
  718.                }
  719.             }
  720.             i++;
  721.          }
  722.          if(iterator)
  723.          {
  724.             iterator.seek(bookmark,0);
  725.          }
  726.          return h;
  727.       }
  728.       
  729.       mx_internal function callSetupRendererFromData(param1:IListItemRenderer, param2:Object) : void
  730.       {
  731.          mx_internal::setupRendererFromData(param1,param2);
  732.       }
  733.       
  734.       override protected function drawSelectionIndicator(param1:Sprite, param2:Number, param3:Number, param4:Number, param5:Number, param6:uint, param7:IListItemRenderer) : void
  735.       {
  736.          super.drawSelectionIndicator(param1,0,param3,unscaledWidth - viewMetrics.left - viewMetrics.right,param5,param6,param7);
  737.       }
  738.       
  739.       private function keyFocusChangeHandler(param1:FocusEvent) : void
  740.       {
  741.          if(param1.keyCode == Keyboard.TAB && !param1.isDefaultPrevented() && findNextItemRenderer(param1.shiftKey))
  742.          {
  743.             param1.preventDefault();
  744.          }
  745.       }
  746.       
  747.       public function set editedItemPosition(param1:Object) : void
  748.       {
  749.          var _loc2_:Object = {
  750.             "rowIndex":param1.rowIndex,
  751.             "columnIndex":0
  752.          };
  753.          setEditedItemPosition(_loc2_);
  754.       }
  755.       
  756.       override protected function makeRowsAndColumns(param1:Number, param2:Number, param3:Number, param4:Number, param5:int, param6:int, param7:Boolean = false, param8:uint = 0) : Point
  757.       {
  758.          var paddingRight:Number;
  759.          var xx:Number;
  760.          var rowsMade:int;
  761.          var bSelected:Boolean;
  762.          var paddingLeft:Number;
  763.          var bCaret:Boolean;
  764.          var rowNum:int;
  765.          var colNum:int;
  766.          var ww:Number;
  767.          var more:Boolean;
  768.          var bHighlight:Boolean;
  769.          var valid:Boolean;
  770.          var yy:Number = NaN;
  771.          var hh:Number = NaN;
  772.          var i:int = 0;
  773.          var j:int = 0;
  774.          var item:IListItemRenderer = null;
  775.          var oldItem:IListItemRenderer = null;
  776.          var rowData:BaseListData = null;
  777.          var data:Object = null;
  778.          var wrappedData:Object = null;
  779.          var uid:String = null;
  780.          var rh:Number = NaN;
  781.          var ld:BaseListData = null;
  782.          var rr:Array = null;
  783.          var rowInfo:ListRowInfo = null;
  784.          var dx:Number = NaN;
  785.          var dy:Number = NaN;
  786.          var dw:Number = NaN;
  787.          var dh:Number = NaN;
  788.          var left:Number = param1;
  789.          var top:Number = param2;
  790.          var right:Number = param3;
  791.          var bottom:Number = param4;
  792.          var firstCol:int = param5;
  793.          var firstRow:int = param6;
  794.          var byCount:Boolean = param7;
  795.          var rowsNeeded:uint = param8;
  796.          listContent.mx_internal::allowItemSizeChangeNotification = false;
  797.          paddingLeft = getStyle("paddingLeft");
  798.          paddingRight = getStyle("paddingRight");
  799.          xx = left + paddingLeft - horizontalScrollPosition;
  800.          ww = right - paddingLeft - paddingRight;
  801.          bSelected = false;
  802.          bHighlight = false;
  803.          bCaret = false;
  804.          colNum = 0;
  805.          rowNum = lockedRowCount;
  806.          rowsMade = 0;
  807.          more = true;
  808.          valid = true;
  809.          yy = top;
  810.          rowNum = firstRow;
  811.          more = iterator != null && !iterator.afterLast && iteratorValid;
  812.          while(!byCount && yy < bottom || byCount && rowsNeeded > 0)
  813.          {
  814.             if(byCount)
  815.             {
  816.                rowsNeeded--;
  817.             }
  818.             valid = more;
  819.             wrappedData = more ? iterator.current : null;
  820.             data = wrappedData is ItemWrapper ? wrappedData.data : wrappedData;
  821.             uid = null;
  822.             if(!listItems[rowNum])
  823.             {
  824.                listItems[rowNum] = [];
  825.             }
  826.             if(valid)
  827.             {
  828.                item = listItems[rowNum][colNum];
  829.                uid = itemToUID(wrappedData);
  830.                if(!item || (runningDataEffect && Boolean(dataItemWrappersByRenderer[item]) ? dataItemWrappersByRenderer[item] != wrappedData : item.data != data))
  831.                {
  832.                   if(mx_internal::allowRendererStealingDuringLayout)
  833.                   {
  834.                      item = visibleData[uid];
  835.                      if(!item && wrappedData != data)
  836.                      {
  837.                         item = visibleData[itemToUID(data)];
  838.                      }
  839.                   }
  840.                   if(item)
  841.                   {
  842.                      ld = BaseListData(rowMap[item.name]);
  843.                      if(Boolean(ld) && ld.rowIndex > rowNum)
  844.                      {
  845.                         listItems[ld.rowIndex] = [];
  846.                      }
  847.                      else
  848.                      {
  849.                         item = null;
  850.                      }
  851.                   }
  852.                   if(!item)
  853.                   {
  854.                      item = getReservedOrFreeItemRenderer(wrappedData);
  855.                   }
  856.                   if(!item)
  857.                   {
  858.                      item = createItemRenderer(data);
  859.                      item.owner = this;
  860.                      item.styleName = listContent;
  861.                      listContent.addChild(DisplayObject(item));
  862.                   }
  863.                   oldItem = listItems[rowNum][colNum];
  864.                   if(oldItem)
  865.                   {
  866.                      addToFreeItemRenderers(oldItem);
  867.                   }
  868.                   listItems[rowNum][colNum] = item;
  869.                }
  870.                rowData = makeListData(data,uid,rowNum);
  871.                rowMap[item.name] = rowData;
  872.                if(item is IDropInListItemRenderer)
  873.                {
  874.                   if(data != null)
  875.                   {
  876.                      IDropInListItemRenderer(item).listData = rowData;
  877.                   }
  878.                   else
  879.                   {
  880.                      IDropInListItemRenderer(item).listData = null;
  881.                   }
  882.                }
  883.                item.data = data;
  884.                item.enabled = enabled;
  885.                item.visible = true;
  886.                if(uid != null)
  887.                {
  888.                   visibleData[uid] = item;
  889.                }
  890.                if(wrappedData != data)
  891.                {
  892.                   dataItemWrappersByRenderer[item] = wrappedData;
  893.                }
  894.                item.explicitWidth = ww;
  895.                if(item is IInvalidating && (wordWrapChanged || variableRowHeight))
  896.                {
  897.                   IInvalidating(item).invalidateSize();
  898.                }
  899.                UIComponentGlobals.mx_internal::layoutManager.validateClient(item,true);
  900.                hh = Math.ceil(variableRowHeight ? item.getExplicitOrMeasuredHeight() + mx_internal::cachedPaddingTop + mx_internal::cachedPaddingBottom : rowHeight);
  901.                rh = Number(item.getExplicitOrMeasuredHeight());
  902.                item.setActualSize(ww,variableRowHeight ? rh : rowHeight - mx_internal::cachedPaddingTop - mx_internal::cachedPaddingBottom);
  903.                item.move(xx,yy + mx_internal::cachedPaddingTop);
  904.             }
  905.             else
  906.             {
  907.                hh = rowNum > 0 ? Number(rowInfo[rowNum - 1].height) : rowHeight;
  908.                if(hh == 0)
  909.                {
  910.                   hh = rowHeight;
  911.                }
  912.                oldItem = listItems[rowNum][colNum];
  913.                if(oldItem)
  914.                {
  915.                   addToFreeItemRenderers(oldItem);
  916.                   listItems[rowNum].splice(colNum,1);
  917.                }
  918.             }
  919.             bSelected = selectedData[uid] != null;
  920.             if(wrappedData != data)
  921.             {
  922.                bSelected ||= Boolean(selectedData[itemToUID(data)]);
  923.                bSelected = bSelected && !getRendererSemanticValue(item,ModifiedCollectionView.REPLACEMENT) && !getRendererSemanticValue(item,ModifiedCollectionView.ADDED);
  924.             }
  925.             bHighlight = highlightUID == uid;
  926.             bCaret = caretUID == uid;
  927.             rowInfo[rowNum] = new ListRowInfo(yy,hh,uid,data);
  928.             if(valid)
  929.             {
  930.                drawItem(item,bSelected,bHighlight,bCaret);
  931.             }
  932.             yy += hh;
  933.             rowNum++;
  934.             rowsMade++;
  935.             if(Boolean(iterator) && more)
  936.             {
  937.                try
  938.                {
  939.                   more = iterator.moveNext();
  940.                }
  941.                catch(e:ItemPendingError)
  942.                {
  943.                   lastSeekPending = new ListBaseSeekPending(CursorBookmark.CURRENT,0);
  944.                   e.addResponder(new ItemResponder(seekPendingResultHandler,seekPendingFailureHandler,lastSeekPending));
  945.                   more = false;
  946.                   iteratorValid = false;
  947.                }
  948.             }
  949.          }
  950.          if(!byCount)
  951.          {
  952.             while(rowNum < listItems.length)
  953.             {
  954.                rr = listItems.pop();
  955.                rowInfo.pop();
  956.                while(rr.length)
  957.                {
  958.                   item = rr.pop();
  959.                   addToFreeItemRenderers(item);
  960.                }
  961.             }
  962.          }
  963.          if(itemEditorInstance)
  964.          {
  965.             listContent.setChildIndex(DisplayObject(itemEditorInstance),listContent.numChildren - 1);
  966.             item = listItems[actualRowIndex][actualColIndex];
  967.             rowInfo = rowInfo[actualRowIndex];
  968.             if(Boolean(item) && !rendererIsEditor)
  969.             {
  970.                dx = editorXOffset;
  971.                dy = editorYOffset;
  972.                dw = editorWidthOffset;
  973.                dh = editorHeightOffset;
  974.                layoutEditor(item.x + dx,rowInfo.y + dy,Math.min(item.width + dw,listContent.width - listContent.x - itemEditorInstance.x),Math.min(rowInfo.height + dh,listContent.height - listContent.y - itemEditorInstance.y));
  975.             }
  976.          }
  977.          listContent.mx_internal::allowItemSizeChangeNotification = variableRowHeight;
  978.          return new Point(colNum,rowsMade);
  979.       }
  980.       
  981.       override protected function measure() : void
  982.       {
  983.          super.measure();
  984.          var _loc1_:EdgeMetrics = viewMetrics;
  985.          measuredMinWidth = DEFAULT_MEASURED_MIN_WIDTH;
  986.          if(initialized && variableRowHeight && explicitRowCount < 1 && isNaN(explicitRowHeight))
  987.          {
  988.             measuredHeight = height;
  989.          }
  990.       }
  991.       
  992.       private function findNextItemRenderer(param1:Boolean) : Boolean
  993.       {
  994.          if(!lastEditedItemPosition)
  995.          {
  996.             return false;
  997.          }
  998.          if(_proposedEditedItemPosition !== undefined)
  999.          {
  1000.             return true;
  1001.          }
  1002.          _editedItemPosition = lastEditedItemPosition;
  1003.          var _loc2_:int = int(_editedItemPosition.rowIndex);
  1004.          var _loc3_:int = int(_editedItemPosition.columnIndex);
  1005.          var _loc4_:int = _editedItemPosition.rowIndex + (param1 ? -1 : 1);
  1006.          if(_loc4_ < collection.length && _loc4_ >= 0)
  1007.          {
  1008.             _loc2_ = _loc4_;
  1009.             var _loc5_:ListEvent = new ListEvent(ListEvent.ITEM_EDIT_BEGINNING,false,true);
  1010.             _loc5_.rowIndex = _loc2_;
  1011.             _loc5_.columnIndex = _loc3_;
  1012.             dispatchEvent(_loc5_);
  1013.             return true;
  1014.          }
  1015.          setEditedItemPosition(null);
  1016.          losingFocus = true;
  1017.          setFocus();
  1018.          return false;
  1019.       }
  1020.       
  1021.       override protected function mouseDownHandler(param1:MouseEvent) : void
  1022.       {
  1023.          var _loc2_:IListItemRenderer = null;
  1024.          var _loc3_:Sprite = null;
  1025.          var _loc5_:Point = null;
  1026.          var _loc6_:Boolean = false;
  1027.          _loc2_ = mouseEventToItemRenderer(param1);
  1028.          var _loc4_:Boolean = itemRendererContains(itemEditorInstance,DisplayObject(param1.target));
  1029.          if(!_loc4_)
  1030.          {
  1031.             if(Boolean(_loc2_) && Boolean(_loc2_.data))
  1032.             {
  1033.                _loc5_ = itemRendererToIndices(_loc2_);
  1034.                _loc6_ = true;
  1035.                if(itemEditorInstance)
  1036.                {
  1037.                   _loc6_ = endEdit(ListEventReason.NEW_ROW);
  1038.                }
  1039.                if(!_loc6_)
  1040.                {
  1041.                   return;
  1042.                }
  1043.             }
  1044.             else if(itemEditorInstance)
  1045.             {
  1046.                endEdit(ListEventReason.OTHER);
  1047.             }
  1048.             super.mouseDownHandler(param1);
  1049.          }
  1050.       }
  1051.       
  1052.       override protected function keyDownHandler(param1:KeyboardEvent) : void
  1053.       {
  1054.          if(itemEditorInstance)
  1055.          {
  1056.             return;
  1057.          }
  1058.          super.keyDownHandler(param1);
  1059.       }
  1060.       
  1061.       override protected function focusInHandler(param1:FocusEvent) : void
  1062.       {
  1063.          var _loc2_:* = false;
  1064.          if(param1.target != this)
  1065.          {
  1066.             return;
  1067.          }
  1068.          if(losingFocus)
  1069.          {
  1070.             losingFocus = false;
  1071.             return;
  1072.          }
  1073.          super.focusInHandler(param1);
  1074.          if(editable && !mx_internal::isPressed)
  1075.          {
  1076.             _editedItemPosition = lastEditedItemPosition;
  1077.             _loc2_ = editedItemPosition != null;
  1078.             if(!_editedItemPosition)
  1079.             {
  1080.                _editedItemPosition = {
  1081.                   "rowIndex":0,
  1082.                   "columnIndex":0
  1083.                };
  1084.                _loc2_ = Boolean(listItems.length) && listItems[0].length > 0;
  1085.             }
  1086.             if(_loc2_)
  1087.             {
  1088.                setEditedItemPosition(_editedItemPosition);
  1089.             }
  1090.          }
  1091.          if(editable)
  1092.          {
  1093.             addEventListener(FocusEvent.KEY_FOCUS_CHANGE,keyFocusChangeHandler);
  1094.             addEventListener(MouseEvent.MOUSE_DOWN,mouseFocusChangeHandler);
  1095.          }
  1096.       }
  1097.       
  1098.       override protected function mouseEventToItemRenderer(param1:MouseEvent) : IListItemRenderer
  1099.       {
  1100.          var _loc2_:IListItemRenderer = super.mouseEventToItemRenderer(param1);
  1101.          return _loc2_ == itemEditorInstance ? null : _loc2_;
  1102.       }
  1103.       
  1104.       protected function makeListData(param1:Object, param2:String, param3:int) : BaseListData
  1105.       {
  1106.          return new ListData(itemToLabel(param1),itemToIcon(param1),labelField,param2,this,param3);
  1107.       }
  1108.       
  1109.       public function createItemEditor(param1:int, param2:int) : void
  1110.       {
  1111.          var _loc5_:Number = NaN;
  1112.          var _loc6_:Number = NaN;
  1113.          var _loc7_:Number = NaN;
  1114.          var _loc8_:Number = NaN;
  1115.          param1 = 0;
  1116.          if(param2 > lockedRowCount)
  1117.          {
  1118.             param2 -= verticalScrollPosition;
  1119.          }
  1120.          var _loc3_:IListItemRenderer = listItems[param2][param1];
  1121.          var _loc4_:ListRowInfo = rowInfo[param2];
  1122.          if(!rendererIsEditor)
  1123.          {
  1124.             _loc5_ = 0;
  1125.             _loc6_ = -2;
  1126.             _loc7_ = 0;
  1127.             _loc8_ = 4;
  1128.             if(!itemEditorInstance)
  1129.             {
  1130.                _loc5_ = editorXOffset;
  1131.                _loc6_ = editorYOffset;
  1132.                _loc7_ = editorWidthOffset;
  1133.                _loc8_ = editorHeightOffset;
  1134.                itemEditorInstance = itemEditor.newInstance();
  1135.                itemEditorInstance.owner = this;
  1136.                itemEditorInstance.styleName = this;
  1137.                listContent.addChild(DisplayObject(itemEditorInstance));
  1138.             }
  1139.             listContent.setChildIndex(DisplayObject(itemEditorInstance),listContent.numChildren - 1);
  1140.             itemEditorInstance.visible = true;
  1141.             layoutEditor(_loc3_.x + _loc5_,_loc4_.y + _loc6_,Math.min(_loc3_.width + _loc7_,listContent.width - listContent.x - itemEditorInstance.x),Math.min(_loc4_.height + _loc8_,listContent.height - listContent.y - itemEditorInstance.y));
  1142.             DisplayObject(itemEditorInstance).addEventListener("focusOut",itemEditorFocusOutHandler);
  1143.          }
  1144.          else
  1145.          {
  1146.             itemEditorInstance = _loc3_;
  1147.          }
  1148.          DisplayObject(itemEditorInstance).addEventListener(KeyboardEvent.KEY_DOWN,editorKeyDownHandler);
  1149.          stage.addEventListener(MouseEvent.MOUSE_DOWN,editorMouseDownHandler,true,0,true);
  1150.       }
  1151.       
  1152.       public function get lockedRowCount() : int
  1153.       {
  1154.          return mx_internal::_lockedRowCount;
  1155.       }
  1156.       
  1157.       override public function set enabled(param1:Boolean) : void
  1158.       {
  1159.          super.enabled = param1;
  1160.          if(itemEditorInstance)
  1161.          {
  1162.             endEdit(ListEventReason.OTHER);
  1163.          }
  1164.          invalidateDisplayList();
  1165.       }
  1166.       
  1167.       protected function endEdit(param1:String) : Boolean
  1168.       {
  1169.          if(!editedItemRenderer)
  1170.          {
  1171.             return true;
  1172.          }
  1173.          inEndEdit = true;
  1174.          var _loc2_:ListEvent = new ListEvent(ListEvent.ITEM_EDIT_END,false,true);
  1175.          _loc2_.rowIndex = editedItemPosition.rowIndex;
  1176.          _loc2_.itemRenderer = editedItemRenderer;
  1177.          _loc2_.reason = param1;
  1178.          dispatchEvent(_loc2_);
  1179.          dontEdit = itemEditorInstance != null;
  1180.          if(!dontEdit && param1 == ListEventReason.CANCELLED)
  1181.          {
  1182.             losingFocus = true;
  1183.             setFocus();
  1184.          }
  1185.          inEndEdit = false;
  1186.          return !_loc2_.isDefaultPrevented();
  1187.       }
  1188.       
  1189.       override protected function collectionChangeHandler(param1:Event) : void
  1190.       {
  1191.          var _loc2_:CollectionEvent = null;
  1192.          if(param1 is CollectionEvent)
  1193.          {
  1194.             _loc2_ = CollectionEvent(param1);
  1195.             if(_loc2_.kind == CollectionEventKind.REMOVE)
  1196.             {
  1197.                if(editedItemPosition)
  1198.                {
  1199.                   if(collection.length == 0)
  1200.                   {
  1201.                      if(itemEditorInstance)
  1202.                      {
  1203.                         endEdit(ListEventReason.CANCELLED);
  1204.                      }
  1205.                      setEditedItemPosition(null);
  1206.                   }
  1207.                   else if(_loc2_.location <= editedItemPosition.rowIndex)
  1208.                   {
  1209.                      if(inEndEdit)
  1210.                      {
  1211.                         _editedItemPosition = {
  1212.                            "columnIndex":editedItemPosition.columnIndex,
  1213.                            "rowIndex":Math.max(0,editedItemPosition.rowIndex - _loc2_.items.length)
  1214.                         };
  1215.                      }
  1216.                      else
  1217.                      {
  1218.                         setEditedItemPosition({
  1219.                            "columnIndex":editedItemPosition.columnIndex,
  1220.                            "rowIndex":Math.max(0,editedItemPosition.rowIndex - _loc2_.items.length)
  1221.                         });
  1222.                      }
  1223.                   }
  1224.                }
  1225.             }
  1226.          }
  1227.          super.collectionChangeHandler(param1);
  1228.       }
  1229.       
  1230.       override public function get baselinePosition() : Number
  1231.       {
  1232.          if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  1233.          {
  1234.             if(Boolean(listItems.length) && Boolean(listItems[0].length))
  1235.             {
  1236.                return borderMetrics.top + mx_internal::cachedPaddingTop + listItems[0][0].baselinePosition;
  1237.             }
  1238.             return NaN;
  1239.          }
  1240.          return super.baselinePosition;
  1241.       }
  1242.       
  1243.       private function itemEditorFocusOutHandler(param1:FocusEvent) : void
  1244.       {
  1245.          if(Boolean(param1.relatedObject) && contains(param1.relatedObject))
  1246.          {
  1247.             return;
  1248.          }
  1249.          if(!param1.relatedObject)
  1250.          {
  1251.             return;
  1252.          }
  1253.          if(itemEditorInstance)
  1254.          {
  1255.             endEdit(ListEventReason.OTHER);
  1256.          }
  1257.       }
  1258.       
  1259.       override public function set dataProvider(param1:Object) : void
  1260.       {
  1261.          if(itemEditorInstance)
  1262.          {
  1263.             endEdit(ListEventReason.OTHER);
  1264.          }
  1265.          super.dataProvider = param1;
  1266.       }
  1267.       
  1268.       override protected function initializeAccessibility() : void
  1269.       {
  1270.          if(mx_internal::createAccessibilityImplementation != null)
  1271.          {
  1272.             mx_internal::createAccessibilityImplementation(this);
  1273.          }
  1274.       }
  1275.       
  1276.       override protected function configureScrollBars() : void
  1277.       {
  1278.          var _loc2_:Number = NaN;
  1279.          var _loc3_:int = 0;
  1280.          var _loc1_:int = int(listItems.length);
  1281.          if(_loc1_ == 0)
  1282.          {
  1283.             return;
  1284.          }
  1285.          var _loc4_:int = int(listItems.length);
  1286.          while(_loc1_ > 1 && rowInfo[_loc4_ - 1].y + rowInfo[_loc4_ - 1].height > listContent.height - listContent.bottomOffset)
  1287.          {
  1288.             _loc1_--;
  1289.             _loc4_--;
  1290.          }
  1291.          var _loc5_:int = verticalScrollPosition - lockedRowCount - 1;
  1292.          var _loc6_:int = 0;
  1293.          while(Boolean(_loc1_) && listItems[_loc1_ - 1].length == 0)
  1294.          {
  1295.             if(!(Boolean(collection) && _loc1_ + _loc5_ >= collection.length))
  1296.             {
  1297.                break;
  1298.             }
  1299.             _loc1_--;
  1300.             _loc6_++;
  1301.          }
  1302.          if(verticalScrollPosition > 0 && _loc6_ > 0 && !runningDataEffect)
  1303.          {
  1304.             if(adjustVerticalScrollPositionDownward(Math.max(_loc1_,1)))
  1305.             {
  1306.                return;
  1307.             }
  1308.          }
  1309.          if(listContent.topOffset)
  1310.          {
  1311.             _loc2_ = Math.abs(listContent.topOffset);
  1312.             _loc3_ = 0;
  1313.             while(rowInfo[_loc3_].y + rowInfo[_loc3_].height <= _loc2_)
  1314.             {
  1315.                _loc1_--;
  1316.                _loc3_++;
  1317.                if(_loc3_ == _loc1_)
  1318.                {
  1319.                   break;
  1320.                }
  1321.             }
  1322.          }
  1323.          var _loc7_:int = int(listItems[0].length);
  1324.          var _loc8_:Object = horizontalScrollBar;
  1325.          var _loc9_:Object = verticalScrollBar;
  1326.          var _loc10_:int = Math.round(unscaledWidth);
  1327.          var _loc11_:int = !!collection ? collection.length - lockedRowCount : 0;
  1328.          var _loc12_:int = _loc1_ - lockedRowCount;
  1329.          setScrollBarProperties(isNaN(mx_internal::_maxHorizontalScrollPosition) ? int(Math.round(listContent.width)) : int(Math.round(mx_internal::_maxHorizontalScrollPosition + _loc10_)),_loc10_,_loc11_,_loc12_);
  1330.          maxVerticalScrollPosition = Math.max(_loc11_ - _loc12_,0);
  1331.       }
  1332.       
  1333.       override protected function mouseWheelHandler(param1:MouseEvent) : void
  1334.       {
  1335.          if(itemEditorInstance)
  1336.          {
  1337.             endEdit(ListEventReason.OTHER);
  1338.          }
  1339.          super.mouseWheelHandler(param1);
  1340.       }
  1341.       
  1342.       override public function set maxHorizontalScrollPosition(param1:Number) : void
  1343.       {
  1344.          super.maxHorizontalScrollPosition = param1;
  1345.          scrollAreaChanged = true;
  1346.          invalidateDisplayList();
  1347.       }
  1348.       
  1349.       override protected function scrollHandler(param1:Event) : void
  1350.       {
  1351.          var scrollBar:ScrollBar = null;
  1352.          var pos:Number = NaN;
  1353.          var delta:int = 0;
  1354.          var o:EdgeMetrics = null;
  1355.          var bookmark:CursorBookmark = null;
  1356.          var event:Event = param1;
  1357.          if(event is ScrollEvent)
  1358.          {
  1359.             if(itemEditorInstance)
  1360.             {
  1361.                endEdit(ListEventReason.OTHER);
  1362.             }
  1363.             if(!liveScrolling && ScrollEvent(event).detail == ScrollEventDetail.THUMB_TRACK)
  1364.             {
  1365.                return;
  1366.             }
  1367.             scrollBar = ScrollBar(event.target);
  1368.             pos = scrollBar.scrollPosition;
  1369.             mx_internal::removeClipMask();
  1370.             if(scrollBar == verticalScrollBar)
  1371.             {
  1372.                delta = pos - verticalScrollPosition;
  1373.                super.scrollHandler(event);
  1374.                if(Math.abs(delta) >= listItems.length - lockedRowCount || !iteratorValid)
  1375.                {
  1376.                   try
  1377.                   {
  1378.                      if(!iteratorValid)
  1379.                      {
  1380.                         iterator.seek(CursorBookmark.FIRST,pos);
  1381.                      }
  1382.                      else
  1383.                      {
  1384.                         iterator.seek(CursorBookmark.CURRENT,delta);
  1385.                      }
  1386.                      if(!iteratorValid)
  1387.                      {
  1388.                         iteratorValid = true;
  1389.                         lastSeekPending = null;
  1390.                      }
  1391.                   }
  1392.                   catch(e:ItemPendingError)
  1393.                   {
  1394.                      lastSeekPending = new ListBaseSeekPending(CursorBookmark.FIRST,pos);
  1395.                      e.addResponder(new ItemResponder(seekPendingResultHandler,seekPendingFailureHandler,lastSeekPending));
  1396.                      iteratorValid = false;
  1397.                   }
  1398.                   bookmark = iterator.bookmark;
  1399.                   clearIndicators();
  1400.                   clearVisibleData();
  1401.                   makeRowsAndColumns(0,0,listContent.width,listContent.height,0,0);
  1402.                   iterator.seek(bookmark,0);
  1403.                }
  1404.                else if(delta != 0)
  1405.                {
  1406.                   scrollVertically(pos,Math.abs(delta),Boolean(delta > 0));
  1407.                }
  1408.                if(variableRowHeight)
  1409.                {
  1410.                   configureScrollBars();
  1411.                }
  1412.                drawRowBackgrounds();
  1413.             }
  1414.             else
  1415.             {
  1416.                delta = pos - mx_internal::_horizontalScrollPosition;
  1417.                super.scrollHandler(event);
  1418.                scrollHorizontally(pos,Math.abs(delta),Boolean(delta > 0));
  1419.             }
  1420.             mx_internal::addClipMask(false);
  1421.          }
  1422.       }
  1423.       
  1424.       public function get editedItemRenderer() : IListItemRenderer
  1425.       {
  1426.          if(!itemEditorInstance)
  1427.          {
  1428.             return null;
  1429.          }
  1430.          return listItems[actualRowIndex][actualColIndex];
  1431.       }
  1432.       
  1433.       private function commitEditedItemPosition(param1:Object) : void
  1434.       {
  1435.          var _loc10_:String = null;
  1436.          if(!enabled || !editable)
  1437.          {
  1438.             return;
  1439.          }
  1440.          if(itemEditorInstance && param1 && itemEditorInstance is IFocusManagerComponent && _editedItemPosition.rowIndex == param1.rowIndex)
  1441.          {
  1442.             IFocusManagerComponent(itemEditorInstance).setFocus();
  1443.             return;
  1444.          }
  1445.          if(itemEditorInstance)
  1446.          {
  1447.             if(!param1)
  1448.             {
  1449.                _loc10_ = ListEventReason.OTHER;
  1450.             }
  1451.             else
  1452.             {
  1453.                _loc10_ = ListEventReason.NEW_ROW;
  1454.             }
  1455.             if(!endEdit(_loc10_) && _loc10_ != ListEventReason.OTHER)
  1456.             {
  1457.                return;
  1458.             }
  1459.          }
  1460.          _editedItemPosition = param1;
  1461.          if(!param1 || dontEdit)
  1462.          {
  1463.             return;
  1464.          }
  1465.          var _loc2_:int = int(param1.rowIndex);
  1466.          var _loc3_:int = int(param1.columnIndex);
  1467.          if(selectedIndex != param1.rowIndex)
  1468.          {
  1469.             mx_internal::commitSelectedIndex(param1.rowIndex);
  1470.          }
  1471.          var _loc4_:int = lockedRowCount;
  1472.          var _loc5_:int = verticalScrollPosition + listItems.length - offscreenExtraRowsTop - offscreenExtraRowsBottom - 1;
  1473.          var _loc6_:int = rowInfo[listItems.length - offscreenExtraRowsBottom - 1].y + rowInfo[listItems.length - offscreenExtraRowsBottom - 1].height > listContent.height ? 1 : 0;
  1474.          if(_loc2_ > _loc4_)
  1475.          {
  1476.             if(_loc2_ < verticalScrollPosition + _loc4_)
  1477.             {
  1478.                verticalScrollPosition = _loc2_ - _loc4_;
  1479.             }
  1480.             else
  1481.             {
  1482.                while(_loc2_ > _loc5_ || _loc2_ == _loc5_ && _loc2_ > verticalScrollPosition + _loc4_ && _loc6_)
  1483.                {
  1484.                   if(verticalScrollPosition == maxVerticalScrollPosition)
  1485.                   {
  1486.                      break;
  1487.                   }
  1488.                   verticalScrollPosition = Math.min(verticalScrollPosition + (_loc2_ > _loc5_ ? _loc2_ - _loc5_ : _loc6_),maxVerticalScrollPosition);
  1489.                   _loc5_ = verticalScrollPosition + listItems.length - offscreenExtraRowsTop - offscreenExtraRowsBottom - 1;
  1490.                   _loc6_ = rowInfo[listItems.length - offscreenExtraRowsBottom - 1].y + rowInfo[listItems.length - offscreenExtraRowsBottom - 1].height > listContent.height ? 1 : 0;
  1491.                }
  1492.             }
  1493.             actualRowIndex = _loc2_ - verticalScrollPosition;
  1494.          }
  1495.          else
  1496.          {
  1497.             if(_loc2_ == _loc4_)
  1498.             {
  1499.                verticalScrollPosition = 0;
  1500.             }
  1501.             actualRowIndex = _loc2_;
  1502.          }
  1503.          var _loc7_:EdgeMetrics = borderMetrics;
  1504.          actualColIndex = _loc3_;
  1505.          var _loc8_:IListItemRenderer = listItems[actualRowIndex][actualColIndex];
  1506.          if(!_loc8_)
  1507.          {
  1508.             commitEditedItemPosition(null);
  1509.             return;
  1510.          }
  1511.          if(!isItemEditable(_loc8_.data))
  1512.          {
  1513.             commitEditedItemPosition(null);
  1514.             return;
  1515.          }
  1516.          var _loc9_:ListEvent = new ListEvent(ListEvent.ITEM_EDIT_BEGIN,false,true);
  1517.          _loc9_.rowIndex = _editedItemPosition.rowIndex;
  1518.          _loc9_.itemRenderer = _loc8_;
  1519.          dispatchEvent(_loc9_);
  1520.          lastEditedItemPosition = _editedItemPosition;
  1521.          if(bEditedItemPositionChanged)
  1522.          {
  1523.             bEditedItemPositionChanged = false;
  1524.             commitEditedItemPosition(_proposedEditedItemPosition);
  1525.             _proposedEditedItemPosition = undefined;
  1526.          }
  1527.          if(!itemEditorInstance)
  1528.          {
  1529.             commitEditedItemPosition(null);
  1530.          }
  1531.       }
  1532.       
  1533.       protected function drawRowBackground(param1:Sprite, param2:int, param3:Number, param4:Number, param5:uint, param6:int) : void
  1534.       {
  1535.          var _loc7_:Shape = null;
  1536.          if(param2 < param1.numChildren)
  1537.          {
  1538.             _loc7_ = Shape(param1.getChildAt(param2));
  1539.          }
  1540.          else
  1541.          {
  1542.             _loc7_ = new FlexShape();
  1543.             _loc7_.name = "rowBackground";
  1544.             param1.addChild(_loc7_);
  1545.          }
  1546.          param4 = Math.min(rowInfo[param2].height,listContent.height - rowInfo[param2].y);
  1547.          _loc7_.y = rowInfo[param2].y;
  1548.          var _loc8_:Graphics = _loc7_.graphics;
  1549.          _loc8_.clear();
  1550.          _loc8_.beginFill(param5,getStyle("backgroundAlpha"));
  1551.          _loc8_.drawRect(0,0,listContent.width,param4);
  1552.          _loc8_.endFill();
  1553.       }
  1554.       
  1555.       override protected function commitProperties() : void
  1556.       {
  1557.          var _loc1_:Number = NaN;
  1558.          var _loc2_:Number = NaN;
  1559.          var _loc3_:IListItemRenderer = null;
  1560.          var _loc4_:Number = NaN;
  1561.          var _loc5_:int = 0;
  1562.          super.commitProperties();
  1563.          if(itemsNeedMeasurement)
  1564.          {
  1565.             itemsNeedMeasurement = false;
  1566.             if(isNaN(explicitRowHeight))
  1567.             {
  1568.                if(iterator)
  1569.                {
  1570.                   _loc1_ = getStyle("paddingTop");
  1571.                   _loc2_ = getStyle("paddingBottom");
  1572.                   _loc3_ = mx_internal::getMeasuringRenderer(iterator.current);
  1573.                   _loc4_ = 200;
  1574.                   if(listContent.width)
  1575.                   {
  1576.                      _loc4_ = listContent.width;
  1577.                   }
  1578.                   _loc3_.explicitWidth = _loc4_;
  1579.                   mx_internal::setupRendererFromData(_loc3_,iterator.current);
  1580.                   _loc5_ = _loc3_.getExplicitOrMeasuredHeight() + _loc1_ + _loc2_;
  1581.                   setRowHeight(Math.max(_loc5_,20));
  1582.                }
  1583.                else
  1584.                {
  1585.                   setRowHeight(20);
  1586.                }
  1587.             }
  1588.             if(isNaN(explicitColumnWidth))
  1589.             {
  1590.                mx_internal::setColumnWidth(measureWidthOfItems(0,explicitRowCount < 1 ? defaultRowCount : explicitRowCount));
  1591.             }
  1592.          }
  1593.       }
  1594.       
  1595.       mx_internal function getMeasuringRenderer(param1:Object) : IListItemRenderer
  1596.       {
  1597.          var _loc2_:IListItemRenderer = null;
  1598.          if(!measuringObjects)
  1599.          {
  1600.             measuringObjects = new Dictionary(true);
  1601.          }
  1602.          var _loc3_:IFactory = getItemRendererFactory(param1);
  1603.          _loc2_ = measuringObjects[_loc3_];
  1604.          if(!_loc2_)
  1605.          {
  1606.             _loc2_ = createItemRenderer(param1);
  1607.             _loc2_.owner = this;
  1608.             _loc2_.name = "hiddenItem";
  1609.             _loc2_.visible = false;
  1610.             _loc2_.styleName = listContent;
  1611.             listContent.addChild(DisplayObject(_loc2_));
  1612.             measuringObjects[_loc3_] = _loc2_;
  1613.          }
  1614.          return _loc2_;
  1615.       }
  1616.       
  1617.       mx_internal function purgeMeasuringRenderers() : void
  1618.       {
  1619.          var _loc1_:IListItemRenderer = null;
  1620.          for each(_loc1_ in measuringObjects)
  1621.          {
  1622.             if(_loc1_.parent)
  1623.             {
  1624.                _loc1_.parent.removeChild(DisplayObject(_loc1_));
  1625.             }
  1626.          }
  1627.          if(!measuringObjects)
  1628.          {
  1629.             measuringObjects = new Dictionary(true);
  1630.          }
  1631.       }
  1632.       
  1633.       private function adjustVerticalScrollPositionDownward(param1:int) : Boolean
  1634.       {
  1635.          var item:IListItemRenderer;
  1636.          var n:int = 0;
  1637.          var j:int = 0;
  1638.          var more:Boolean = false;
  1639.          var data:Object = null;
  1640.          var rowCount:int = param1;
  1641.          var bookmark:CursorBookmark = iterator.bookmark;
  1642.          var h:Number = 0;
  1643.          var ch:Number = 0;
  1644.          var paddingTop:Number = getStyle("paddingTop");
  1645.          var paddingBottom:Number = getStyle("paddingBottom");
  1646.          var paddingLeft:Number = getStyle("paddingLeft");
  1647.          var paddingRight:Number = getStyle("paddingRight");
  1648.          h = rowInfo[rowCount - 1].y + rowInfo[rowCount - 1].height;
  1649.          h = listContent.heightExcludingOffsets - listContent.topOffset - h;
  1650.          var numRows:int = 0;
  1651.          try
  1652.          {
  1653.             if(iterator.afterLast)
  1654.             {
  1655.                iterator.seek(CursorBookmark.LAST,0);
  1656.             }
  1657.             else
  1658.             {
  1659.                more = iterator.movePrevious();
  1660.             }
  1661.          }
  1662.          catch(e:ItemPendingError)
  1663.          {
  1664.             more = false;
  1665.          }
  1666.          if(!more)
  1667.          {
  1668.             super.verticalScrollPosition = 0;
  1669.             try
  1670.             {
  1671.                iterator.seek(CursorBookmark.FIRST,0);
  1672.                if(!iteratorValid)
  1673.                {
  1674.                   iteratorValid = true;
  1675.                   lastSeekPending = null;
  1676.                }
  1677.             }
  1678.             catch(e:ItemPendingError)
  1679.             {
  1680.                lastSeekPending = new ListBaseSeekPending(CursorBookmark.FIRST,0);
  1681.                e.addResponder(new ItemResponder(seekPendingResultHandler,seekPendingFailureHandler,lastSeekPending));
  1682.                iteratorValid = false;
  1683.                invalidateList();
  1684.                return true;
  1685.             }
  1686.             updateList();
  1687.             return true;
  1688.          }
  1689.          item = mx_internal::getMeasuringRenderer(iterator.current);
  1690.          item.explicitWidth = listContent.width - paddingLeft - paddingRight;
  1691.          while(h > 0 && more)
  1692.          {
  1693.             if(more)
  1694.             {
  1695.                data = iterator.current;
  1696.                mx_internal::setupRendererFromData(item,data);
  1697.                ch = variableRowHeight ? item.getExplicitOrMeasuredHeight() + paddingBottom + paddingTop : rowHeight;
  1698.             }
  1699.             h -= ch;
  1700.             try
  1701.             {
  1702.                more = iterator.movePrevious();
  1703.                numRows++;
  1704.             }
  1705.             catch(e:ItemPendingError)
  1706.             {
  1707.                more = false;
  1708.             }
  1709.          }
  1710.          if(h < 0)
  1711.          {
  1712.             numRows--;
  1713.          }
  1714.          iterator.seek(bookmark,0);
  1715.          verticalScrollPosition = Math.max(0,verticalScrollPosition - numRows);
  1716.          if(numRows > 0 && !variableRowHeight)
  1717.          {
  1718.             configureScrollBars();
  1719.          }
  1720.          return numRows > 0;
  1721.       }
  1722.       
  1723.       public function isItemEditable(param1:Object) : Boolean
  1724.       {
  1725.          if(!editable)
  1726.          {
  1727.             return false;
  1728.          }
  1729.          if(param1 == null)
  1730.          {
  1731.             return false;
  1732.          }
  1733.          return true;
  1734.       }
  1735.       
  1736.       override protected function adjustListContent(param1:Number = -1, param2:Number = -1) : void
  1737.       {
  1738.          var _loc3_:Number = viewMetrics.left + Math.max(listContent.leftOffset,0);
  1739.          var _loc4_:Number = viewMetrics.top + listContent.topOffset;
  1740.          listContent.move(_loc3_,_loc4_);
  1741.          var _loc5_:Number = Math.max(0,listContent.rightOffset) - _loc3_ - viewMetrics.right;
  1742.          var _loc6_:Number = Math.max(0,listContent.bottomOffset) - _loc4_ - viewMetrics.bottom;
  1743.          var _loc7_:Number = param1 + _loc5_;
  1744.          if(horizontalScrollPolicy == ScrollPolicy.ON || horizontalScrollPolicy == ScrollPolicy.AUTO && !isNaN(mx_internal::_maxHorizontalScrollPosition))
  1745.          {
  1746.             if(isNaN(mx_internal::_maxHorizontalScrollPosition))
  1747.             {
  1748.                _loc7_ *= 2;
  1749.             }
  1750.             else
  1751.             {
  1752.                _loc7_ += mx_internal::_maxHorizontalScrollPosition;
  1753.             }
  1754.          }
  1755.          listContent.setActualSize(_loc7_,param2 + _loc6_);
  1756.       }
  1757.       
  1758.       private function editorMouseDownHandler(param1:MouseEvent) : void
  1759.       {
  1760.          if(!itemRendererContains(itemEditorInstance,DisplayObject(param1.target)))
  1761.          {
  1762.             endEdit(ListEventReason.OTHER);
  1763.          }
  1764.       }
  1765.       
  1766.       override public function set itemRenderer(param1:IFactory) : void
  1767.       {
  1768.          super.itemRenderer = param1;
  1769.          mx_internal::purgeMeasuringRenderers();
  1770.       }
  1771.       
  1772.       mx_internal function setupRendererFromData(param1:IListItemRenderer, param2:Object) : void
  1773.       {
  1774.          var _loc3_:Object = param2 is ItemWrapper ? param2.data : param2;
  1775.          if(param1 is IDropInListItemRenderer)
  1776.          {
  1777.             if(_loc3_ != null)
  1778.             {
  1779.                IDropInListItemRenderer(param1).listData = makeListData(_loc3_,itemToUID(param2),0);
  1780.             }
  1781.             else
  1782.             {
  1783.                IDropInListItemRenderer(param1).listData = null;
  1784.             }
  1785.          }
  1786.          param1.data = _loc3_;
  1787.          if(param1 is IInvalidating)
  1788.          {
  1789.             IInvalidating(param1).invalidateSize();
  1790.          }
  1791.          UIComponentGlobals.mx_internal::layoutManager.validateClient(param1,true);
  1792.       }
  1793.       
  1794.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  1795.       {
  1796.          super.updateDisplayList(param1,param2);
  1797.          setRowCount(listItems.length);
  1798.          if(bEditedItemPositionChanged && !editingTemporarilyPrevented(_proposedEditedItemPosition))
  1799.          {
  1800.             bEditedItemPositionChanged = false;
  1801.             commitEditedItemPosition(_proposedEditedItemPosition);
  1802.             _proposedEditedItemPosition = undefined;
  1803.          }
  1804.          drawRowBackgrounds();
  1805.       }
  1806.       
  1807.       public function destroyItemEditor() : void
  1808.       {
  1809.          var _loc1_:ListEvent = null;
  1810.          if(itemEditorInstance)
  1811.          {
  1812.             DisplayObject(itemEditorInstance).removeEventListener(KeyboardEvent.KEY_DOWN,editorKeyDownHandler);
  1813.             if(stage)
  1814.             {
  1815.                stage.removeEventListener(MouseEvent.MOUSE_DOWN,editorMouseDownHandler,true);
  1816.             }
  1817.             _loc1_ = new ListEvent(ListEvent.ITEM_FOCUS_OUT);
  1818.             _loc1_.rowIndex = _editedItemPosition.rowIndex;
  1819.             _loc1_.itemRenderer = editedItemRenderer;
  1820.             dispatchEvent(_loc1_);
  1821.             if(!rendererIsEditor)
  1822.             {
  1823.                if(Boolean(itemEditorInstance) && itemEditorInstance is UIComponent)
  1824.                {
  1825.                   UIComponent(itemEditorInstance).drawFocus(false);
  1826.                }
  1827.                listContent.removeChild(DisplayObject(itemEditorInstance));
  1828.             }
  1829.             itemEditorInstance = null;
  1830.             _editedItemPosition = null;
  1831.          }
  1832.       }
  1833.       
  1834.       mx_internal function callMakeListData(param1:Object, param2:String, param3:int) : BaseListData
  1835.       {
  1836.          return makeListData(param1,param2,param3);
  1837.       }
  1838.       
  1839.       public function set lockedRowCount(param1:int) : void
  1840.       {
  1841.          mx_internal::_lockedRowCount = param1;
  1842.          invalidateDisplayList();
  1843.       }
  1844.    }
  1845. }
  1846.  
  1847.